#ifndef JSONWRAPPER_H
#define JSONWRAPPER_H
#include <string>
#include <utility>
#include "nlohmann/json.hpp"
#include <QDebug>

using JsonVariant = std::variant<int, double, std::string, bool, nlohmann::json>;

class JsonArray {
public:
    // 添加元素到数组
    void Add(const JsonVariant& value) {
        nlohmann::json jsonValue = std::visit([](const auto& val) {
            return nlohmann::json(val);  // 使用自动类型推导
        }, value);
        m_jsonArray.push_back(jsonValue);
    }

    // 返回 JSON 数组
    nlohmann::json toJson() const {
        return m_jsonArray;
    }

private:
    nlohmann::json m_jsonArray; // 使用 nlohmann::json 来存储数据
};


// 检查类型是否是支持的类型
template<typename T>
struct is_supported_type : std::false_type {};

template<>
struct is_supported_type<int> : std::true_type {};

template<>
struct is_supported_type<double> : std::true_type {};

template<>
struct is_supported_type<std::string> : std::true_type {};

template<>
struct is_supported_type<bool> : std::true_type {};

template<>
struct is_supported_type<nlohmann::json> : std::true_type {};

template<typename T, typename = void>
struct is_std_container : std::false_type {};

// Partial specialization for standard containers
template<typename T>
struct is_std_container<T, std::void_t<
                               typename T::iterator,
                               typename T::const_iterator,
                               typename T::value_type,
                               decltype(std::declval<T>().begin()),
                               decltype(std::declval<T>().end())
                               >> : std::true_type {};

// 将支持的类型添加到 JSON 数组中
template <typename T>
void AddToJsonArray(nlohmann::json& arr, const T& value) {
    static_assert(is_supported_type<T>::value || is_std_container<T>::value, "Unsupported type");
    arr.push_back(value);
}

// 可变参数模板函数
template<typename... Args>
nlohmann::json CreateJsonArray(const Args&... args) {
    nlohmann::json arr = nlohmann::json::array(); // 创建一个 JSON 数组

    (AddToJsonArray(arr, args), ...); // 使用折叠表达式将每个参数添加到数组中

    return arr;
}


// 序列化为 str
template <typename T>
std::string SerializeAsString(const T& st, bool back = false){
    try{
        nlohmann::json json = st;
        if(back)
        {
            return json.dump(4);
        }
        return json.dump();
    }catch(...){
        qCritical() << "SerializeAsString Err Type = " << typeid(T).name();
    }
    return std::string();
}

//反序列化
template <typename T>
std::pair<T, bool> ParseFromString(const std::string& json)
{
    std::pair<T, bool> ret;
    ret.second = false;
    try {
        nlohmann::json js = nlohmann::json::parse(json);

        // 反序列化到 C++ 对象
        ret.first = std::move(js.get<T>());
        ret.second = true;
    } catch (...) {
        qCritical() << "ParseFromString Err Str = " << json.c_str();
    }
    return ret;
}





#endif // JSONWRAPPER_H
